{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import LSTM\n",
    "from tensorflow.keras.layers import Dense, Dropout\n",
    "import pandas as pd\n",
    "from matplotlib import pyplot as plt\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import seaborn as sns"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "outputs": [],
   "source": [
    "df=pd.read_csv(\"patients_number.csv\",parse_dates=[\"date\"], usecols=['date', 'acc_confirmed', 'closers', 'watched', 'in_hospital', 'acc_cured'], skiprows=lambda x: x>19)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0       0\n",
      "1       0\n",
      "2       0\n",
      "3       0\n",
      "4       0\n",
      "5       0\n",
      "6       0\n",
      "7       0\n",
      "8       0\n",
      "9       0\n",
      "10      0\n",
      "11      0\n",
      "12      0\n",
      "13      3\n",
      "14     20\n",
      "15     47\n",
      "16     91\n",
      "17    132\n",
      "18    188\n",
      "Name: acc_cured, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "print(df['acc_cured'])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "outputs": [],
   "source": [
    "# Separate dates for future plotting\n",
    "train_dates = pd.to_datetime(df['date'])\n",
    "# print(train_dates.tail(15))  # Check last few dates."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['acc_confirmed', 'closers', 'watched', 'in_hospital', 'acc_cured']\n"
     ]
    }
   ],
   "source": [
    "# Variables for training\n",
    "cols = list(df)[1:6]\n",
    "# Date and volume columns are not used in training.\n",
    "print(cols)  # ['Open', 'High', 'Low', 'Close', 'Adj Close']"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "outputs": [],
   "source": [
    "# New dataframe with only training data - 5 columns\n",
    "df_for_training = df[cols].astype(float)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "outputs": [
    {
     "data": {
      "text/plain": "<AxesSubplot:>"
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_for_plot=df_for_training.tail(10)\n",
    "df_for_plot.plot.line()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "outputs": [],
   "source": [
    "# LSTM uses sigmoid and tanh that are sensitive to magnitude so values need to be normalized\n",
    "# normalize the dataset\n",
    "scaler = StandardScaler()\n",
    "scaler = scaler.fit(df_for_training)\n",
    "df_for_training_scaled = scaler.transform(df_for_training)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [],
   "source": [
    "# As required for LSTM networks, we require to reshape an input data into n_samples x timesteps x n_features.\n",
    "# In this example, the n_features is 5. We will make timesteps = 14 (past days data used for training).\n",
    "\n",
    "# Empty lists to be populated using formatted training data\n",
    "trainX = []\n",
    "trainY = []"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [],
   "source": [
    "n_future = 1  # Number of days we want to look into the future based on the past days.\n",
    "n_past = 5  # Number of past days we want to use to predict the future."
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trainX shape == (14, 5, 5).\n",
      "trainY shape == (14, 1).\n"
     ]
    }
   ],
   "source": [
    "# Reformat input data into a shape: (n_samples x timesteps x n_features)\n",
    "# In my example, my df_for_training_scaled has a shape (12823, 5)\n",
    "# 12823 refers to the number of data points and 5 refers to the columns (multi-variables).\n",
    "for i in range(n_past, len(df_for_training_scaled) - n_future + 1):\n",
    "    trainX.append(df_for_training_scaled[i - n_past:i, 0:df_for_training.shape[1]])\n",
    "    trainY.append(df_for_training_scaled[i + n_future - 1:i + n_future, 0])\n",
    "\n",
    "trainX, trainY = np.array(trainX), np.array(trainY)\n",
    "\n",
    "print('trainX shape == {}.'.format(trainX.shape))\n",
    "print('trainY shape == {}.'.format(trainY.shape))"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:Layer lstm will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n",
      "WARNING:tensorflow:Layer lstm_1 will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n",
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " lstm (LSTM)                 (None, 5, 64)             17920     \n",
      "                                                                 \n",
      " lstm_1 (LSTM)               (None, 32)                12416     \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 32)                0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 1)                 33        \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 30,369\n",
      "Trainable params: 30,369\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n",
      "Epoch 1/5\n",
      "1/1 [==============================] - 7s 7s/step - loss: 0.5583 - val_loss: 0.9265\n",
      "Epoch 2/5\n",
      "1/1 [==============================] - 0s 91ms/step - loss: 0.5401 - val_loss: 0.8951\n",
      "Epoch 3/5\n",
      "1/1 [==============================] - 0s 93ms/step - loss: 0.5243 - val_loss: 0.8646\n",
      "Epoch 4/5\n",
      "1/1 [==============================] - 0s 250ms/step - loss: 0.4978 - val_loss: 0.8350\n",
      "Epoch 5/5\n",
      "1/1 [==============================] - 0s 87ms/step - loss: 0.4827 - val_loss: 0.8063\n"
     ]
    },
    {
     "data": {
      "text/plain": "<matplotlib.legend.Legend at 0x22e4d6a58b0>"
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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\n"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# define the Autoencoder model\n",
    "\n",
    "model = Sequential()\n",
    "model.add(LSTM(64, activation='relu', input_shape=(trainX.shape[1], trainX.shape[2]), return_sequences=True))\n",
    "model.add(LSTM(32, activation='relu', return_sequences=False))\n",
    "model.add(Dropout(0.2))\n",
    "model.add(Dense(trainY.shape[1]))\n",
    "\n",
    "model.compile(optimizer='adam', loss='mse')\n",
    "model.summary()\n",
    "\n",
    "# fit the model\n",
    "history = model.fit(trainX, trainY, epochs=5, batch_size=16, validation_split=0.1, verbose=1)\n",
    "\n",
    "plt.plot(history.history['loss'], label='Training loss')\n",
    "plt.plot(history.history['val_loss'], label='Validation loss')\n",
    "plt.legend()"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Timestamp('2022-01-18 00:00:00', freq='C'), Timestamp('2022-01-19 00:00:00', freq='C'), Timestamp('2022-01-20 00:00:00', freq='C'), Timestamp('2022-01-21 00:00:00', freq='C'), Timestamp('2022-01-24 00:00:00', freq='C'), Timestamp('2022-01-25 00:00:00', freq='C'), Timestamp('2022-01-26 00:00:00', freq='C'), Timestamp('2022-01-27 00:00:00', freq='C'), Timestamp('2022-01-28 00:00:00', freq='C'), Timestamp('2022-01-31 00:00:00', freq='C'), Timestamp('2022-02-01 00:00:00', freq='C'), Timestamp('2022-02-02 00:00:00', freq='C'), Timestamp('2022-02-03 00:00:00', freq='C'), Timestamp('2022-02-04 00:00:00', freq='C'), Timestamp('2022-02-07 00:00:00', freq='C')]\n"
     ]
    }
   ],
   "source": [
    "# Predicting...\n",
    "# Libraries that will help us extract only business days in the US.\n",
    "# Otherwise our dates would be wrong when we look back (or forward).\n",
    "from pandas.tseries.holiday import USFederalHolidayCalendar\n",
    "from pandas.tseries.offsets import CustomBusinessDay\n",
    "\n",
    "us_bd = CustomBusinessDay(calendar=USFederalHolidayCalendar())\n",
    "# Remember that we can only predict one day in future as our model needs 5 variables\n",
    "# as inputs for prediction. We only have all 5 variables until the last day in our dataset.\n",
    "n_past = 12\n",
    "n_days_for_prediction = 15  # let us predict past 15 days\n",
    "\n",
    "predict_period_dates = pd.date_range(list(train_dates)[-n_past], periods=n_days_for_prediction, freq=us_bd).tolist()\n",
    "print(predict_period_dates)"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 1s 503ms/step\n"
     ]
    }
   ],
   "source": [
    "# Make prediction\n",
    "prediction = model.predict(trainX[-n_days_for_prediction:])  # shape = (n, 1) where n is the n_days_for_prediction\n",
    "\n",
    "# Perform inverse transformation to rescale back to original range\n",
    "# Since we used 5 variables for transform, the inverse expects same dimensions\n",
    "# Therefore, let us copy our values 5 times and discard them after inverse transform\n",
    "prediction_copies = np.repeat(prediction, df_for_training.shape[1], axis=-1)\n",
    "y_pred_future = scaler.inverse_transform(prediction_copies)[:, 0]"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "All arrays must be of the same length",
     "output_type": "error",
     "traceback": [
      "\u001B[1;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[1;31mValueError\u001B[0m                                Traceback (most recent call last)",
      "Cell \u001B[1;32mIn [18], line 6\u001B[0m\n\u001B[0;32m      3\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m time_i \u001B[38;5;129;01min\u001B[39;00m predict_period_dates:\n\u001B[0;32m      4\u001B[0m     forecast_dates\u001B[38;5;241m.\u001B[39mappend(time_i\u001B[38;5;241m.\u001B[39mdate())\n\u001B[1;32m----> 6\u001B[0m df_forecast \u001B[38;5;241m=\u001B[39m \u001B[43mpd\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mDataFrame\u001B[49m\u001B[43m(\u001B[49m\u001B[43m{\u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43mdate\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m:\u001B[49m\u001B[43m \u001B[49m\u001B[43mnp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43marray\u001B[49m\u001B[43m(\u001B[49m\u001B[43mforecast_dates\u001B[49m\u001B[43m)\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[38;5;124;43macc_confirmed\u001B[39;49m\u001B[38;5;124;43m'\u001B[39;49m\u001B[43m:\u001B[49m\u001B[43m \u001B[49m\u001B[43my_pred_future\u001B[49m\u001B[43m}\u001B[49m\u001B[43m)\u001B[49m\n\u001B[0;32m      7\u001B[0m df_forecast[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mdate\u001B[39m\u001B[38;5;124m'\u001B[39m] \u001B[38;5;241m=\u001B[39m pd\u001B[38;5;241m.\u001B[39mto_datetime(df_forecast[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mdate\u001B[39m\u001B[38;5;124m'\u001B[39m])\n\u001B[0;32m      9\u001B[0m original \u001B[38;5;241m=\u001B[39m df[[\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mdate\u001B[39m\u001B[38;5;124m'\u001B[39m, \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mconfirmed\u001B[39m\u001B[38;5;124m'\u001B[39m]]\n",
      "File \u001B[1;32mD:\\env\\python\\anaconda\\envs\\covid\\lib\\site-packages\\pandas\\core\\frame.py:636\u001B[0m, in \u001B[0;36mDataFrame.__init__\u001B[1;34m(self, data, index, columns, dtype, copy)\u001B[0m\n\u001B[0;32m    630\u001B[0m     mgr \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39m_init_mgr(\n\u001B[0;32m    631\u001B[0m         data, axes\u001B[38;5;241m=\u001B[39m{\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mindex\u001B[39m\u001B[38;5;124m\"\u001B[39m: index, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mcolumns\u001B[39m\u001B[38;5;124m\"\u001B[39m: columns}, dtype\u001B[38;5;241m=\u001B[39mdtype, copy\u001B[38;5;241m=\u001B[39mcopy\n\u001B[0;32m    632\u001B[0m     )\n\u001B[0;32m    634\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(data, \u001B[38;5;28mdict\u001B[39m):\n\u001B[0;32m    635\u001B[0m     \u001B[38;5;66;03m# GH#38939 de facto copy defaults to False only in non-dict cases\u001B[39;00m\n\u001B[1;32m--> 636\u001B[0m     mgr \u001B[38;5;241m=\u001B[39m \u001B[43mdict_to_mgr\u001B[49m\u001B[43m(\u001B[49m\u001B[43mdata\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mindex\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcolumns\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mdtype\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdtype\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcopy\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcopy\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtyp\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mmanager\u001B[49m\u001B[43m)\u001B[49m\n\u001B[0;32m    637\u001B[0m \u001B[38;5;28;01melif\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(data, ma\u001B[38;5;241m.\u001B[39mMaskedArray):\n\u001B[0;32m    638\u001B[0m     \u001B[38;5;28;01mimport\u001B[39;00m \u001B[38;5;21;01mnumpy\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mma\u001B[39;00m\u001B[38;5;21;01m.\u001B[39;00m\u001B[38;5;21;01mmrecords\u001B[39;00m \u001B[38;5;28;01mas\u001B[39;00m \u001B[38;5;21;01mmrecords\u001B[39;00m\n",
      "File \u001B[1;32mD:\\env\\python\\anaconda\\envs\\covid\\lib\\site-packages\\pandas\\core\\internals\\construction.py:502\u001B[0m, in \u001B[0;36mdict_to_mgr\u001B[1;34m(data, index, columns, dtype, typ, copy)\u001B[0m\n\u001B[0;32m    494\u001B[0m     arrays \u001B[38;5;241m=\u001B[39m [\n\u001B[0;32m    495\u001B[0m         x\n\u001B[0;32m    496\u001B[0m         \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28mhasattr\u001B[39m(x, \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mdtype\u001B[39m\u001B[38;5;124m\"\u001B[39m) \u001B[38;5;129;01mor\u001B[39;00m \u001B[38;5;129;01mnot\u001B[39;00m \u001B[38;5;28misinstance\u001B[39m(x\u001B[38;5;241m.\u001B[39mdtype, ExtensionDtype)\n\u001B[0;32m    497\u001B[0m         \u001B[38;5;28;01melse\u001B[39;00m x\u001B[38;5;241m.\u001B[39mcopy()\n\u001B[0;32m    498\u001B[0m         \u001B[38;5;28;01mfor\u001B[39;00m x \u001B[38;5;129;01min\u001B[39;00m arrays\n\u001B[0;32m    499\u001B[0m     ]\n\u001B[0;32m    500\u001B[0m     \u001B[38;5;66;03m# TODO: can we get rid of the dt64tz special case above?\u001B[39;00m\n\u001B[1;32m--> 502\u001B[0m \u001B[38;5;28;01mreturn\u001B[39;00m \u001B[43marrays_to_mgr\u001B[49m\u001B[43m(\u001B[49m\u001B[43marrays\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mcolumns\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mindex\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mdtype\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mdtype\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mtyp\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mtyp\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mconsolidate\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mcopy\u001B[49m\u001B[43m)\u001B[49m\n",
      "File \u001B[1;32mD:\\env\\python\\anaconda\\envs\\covid\\lib\\site-packages\\pandas\\core\\internals\\construction.py:120\u001B[0m, in \u001B[0;36marrays_to_mgr\u001B[1;34m(arrays, columns, index, dtype, verify_integrity, typ, consolidate)\u001B[0m\n\u001B[0;32m    117\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m verify_integrity:\n\u001B[0;32m    118\u001B[0m     \u001B[38;5;66;03m# figure out the index, if necessary\u001B[39;00m\n\u001B[0;32m    119\u001B[0m     \u001B[38;5;28;01mif\u001B[39;00m index \u001B[38;5;129;01mis\u001B[39;00m \u001B[38;5;28;01mNone\u001B[39;00m:\n\u001B[1;32m--> 120\u001B[0m         index \u001B[38;5;241m=\u001B[39m \u001B[43m_extract_index\u001B[49m\u001B[43m(\u001B[49m\u001B[43marrays\u001B[49m\u001B[43m)\u001B[49m\n\u001B[0;32m    121\u001B[0m     \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[0;32m    122\u001B[0m         index \u001B[38;5;241m=\u001B[39m ensure_index(index)\n",
      "File \u001B[1;32mD:\\env\\python\\anaconda\\envs\\covid\\lib\\site-packages\\pandas\\core\\internals\\construction.py:674\u001B[0m, in \u001B[0;36m_extract_index\u001B[1;34m(data)\u001B[0m\n\u001B[0;32m    672\u001B[0m lengths \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mlist\u001B[39m(\u001B[38;5;28mset\u001B[39m(raw_lengths))\n\u001B[0;32m    673\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mlen\u001B[39m(lengths) \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m1\u001B[39m:\n\u001B[1;32m--> 674\u001B[0m     \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mAll arrays must be of the same length\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n\u001B[0;32m    676\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m have_dicts:\n\u001B[0;32m    677\u001B[0m     \u001B[38;5;28;01mraise\u001B[39;00m \u001B[38;5;167;01mValueError\u001B[39;00m(\n\u001B[0;32m    678\u001B[0m         \u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mMixing dicts with non-Series may lead to ambiguous ordering.\u001B[39m\u001B[38;5;124m\"\u001B[39m\n\u001B[0;32m    679\u001B[0m     )\n",
      "\u001B[1;31mValueError\u001B[0m: All arrays must be of the same length"
     ]
    }
   ],
   "source": [
    "# Convert timestamp to date\n",
    "forecast_dates = []\n",
    "for time_i in predict_period_dates:\n",
    "    forecast_dates.append(time_i.date())\n",
    "\n",
    "df_forecast = pd.DataFrame({'date': np.array(forecast_dates), 'acc_confirmed': y_pred_future})\n",
    "df_forecast['date'] = pd.to_datetime(df_forecast['date'])\n",
    "\n",
    "original = df[['date', 'confirmed']]\n",
    "original['date'] = pd.to_datetime(original['date'])\n",
    "original = original.loc[original['date'] >= '2022-1-8']\n",
    "\n",
    "sns.lineplot(original['date'], original['acc_confirmed'])\n",
    "sns.lineplot(df_forecast['date'], df_forecast['acc_confirmed'])"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}